<!-- eslint-disable prettier/prettier -->
<template>
  <div id="aiReportView">
    <!-- 头部选择区域 -->
    <div class="header-section">
      <h1 class="page-title">题目分析</h1>
      <div class="selection-container">
        <a-form :model="searchParams" layout="inline">
          <a-form-item
            field="questionId"
            label="题目名称："
            tooltip="选择要分析的题目"
            style="min-width: 240px"
          >
            <a-select
              v-model="searchParams.questionId"
              :style="{ width: '340px' }"
              placeholder="选择题目"
              allow-search
              class="question-select"
            >
              <a-option value="1869392320718675970">两数之和</a-option>
              <a-option value="1886035277244100609">狼抓兔子</a-option>
              <a-option value="1886035673291255809">轮状病毒</a-option>
              <a-option value="1917138790665732098">两数相加</a-option>
              <a-option value="1918578593986801666">多数元素</a-option>
              <a-option value="1918579473574293506">完全平方数</a-option>
            </a-select>
          </a-form-item>

          <a-form-item>
            <a-button
              type="primary"
              @click="generateReport"
              :loading="isGenerating"
              class="generate-btn"
            >
              生成分析报告
            </a-button>
          </a-form-item>
        </a-form>
      </div>
    </div>

    <!-- 分析报告加载状态 -->
    <div v-if="isGenerating" class="loading-container">
      <a-spin dot :size="36" />
      <div class="loading-text">
        <h2>正在生成分析报告</h2>
        <p class="loading-tips">
          正在分析所有提交记录、查找最优解法、总结常见错误...
        </p>
      </div>
    </div>

    <!-- 未选择题目或未生成报告 -->
    <div v-if="!isGenerating && !reportGenerated" class="empty-container">
      <div class="empty-content">
        <icon-robot class="empty-icon" />
        <h2 class="empty-title">请选择题目进行分析</h2>
        <p class="empty-desc">选择一道题目并点击"生成分析报告"按钮，AI将为您生成详细的解题分析</p>
      </div>
    </div>

    <!-- 结果显示区域 -->
    <div v-if="reportGenerated" class="report-container">
      <!-- 分析概览 -->
      <div class="report-section">
        <div class="section-header">
          <icon-info-circle class="section-icon" />
          <h2 class="section-title">分析概览</h2>
        </div>
        <a-descriptions
          :data="overviewData"
          layout="horizontal"
          :column="{ xs: 1, sm: 2, md: 3, lg: 4 }"
          bordered
          class="overview-descriptions"
        />
      </div>

      <!-- 解题思路分析 -->
      <a-collapse :default-active-key="['1']" class="report-section">
        <a-collapse-item key="1">
          <template #header>
            <div class="section-header">
              <icon-bulb class="section-icon" />
              <span class="section-title">解题思路分析</span>
            </div>
          </template>
          <div class="solution-analysis">
            <div class="analysis-item">
              <h3>问题理解</h3>
              <p>{{ solutionAnalysis.understanding }}</p>
            </div>
            <div class="analysis-item">
              <h3><icon-code /> 算法思路</h3>
              <p>{{ solutionAnalysis.approach }}</p>
            </div>
            <div class="analysis-item">
              <h3>时间复杂度分析</h3>
              <p>{{ solutionAnalysis.timeComplexity }}</p>
            </div>
            <div class="analysis-item">
              <h3>空间复杂度分析</h3>
              <p>{{ solutionAnalysis.spaceComplexity }}</p>
            </div>
          </div>
        </a-collapse-item>
      </a-collapse>

      <!-- 最优代码详解 -->
      <a-card class="report-section">
        <template #title>
          <div class="section-header">
            <icon-code class="section-icon" />
            <h2 class="section-title">最优代码详解</h2>
          </div>
        </template>

        <a-tabs>
          <a-tab-pane key="1" title="Java">
            <div class="code-analysis">
              <div class="code-container">
                <AnswerCodeEditor
                  :code="codeAnalysis.java.code"
                  :language="'java'"
                  :handleChange="handleCodeChange"
                />
              </div>
              <div class="explanation-container">
                <h3>代码解释</h3>
                <ul>
                  <li v-for="(item, index) in codeAnalysis.java.explanation" :key="index">
                    {{ item.title }}：{{ item.content }}
                  </li>
                </ul>
              </div>
            </div>
          </a-tab-pane>
          <a-tab-pane key="2" title="C++">
            <div class="code-analysis">
              <div class="code-container">
                <AnswerCodeEditor
                  :code="codeAnalysis.cpp.code"
                  :language="'cpp'"
                  :handleChange="handleCodeChange"
                />
              </div>
              <div class="explanation-container">
                <h3>代码解释</h3>
                <ul>
                  <li v-for="(item, index) in codeAnalysis.cpp.explanation" :key="index">
                    {{ item.title }}：{{ item.content }}
                  </li>
                </ul>
              </div>
            </div>
          </a-tab-pane>
        </a-tabs>
      </a-card>

      <!-- 优化建议 -->
      <a-card class="report-section">
        <template #title>
          <div class="section-header">
            <icon-thumb-up class="section-icon" />
            <h2 class="section-title">优化建议</h2>
          </div>
        </template>
        <div class="optimization-suggestions">
          <ul>
            <li v-for="(item, index) in optimizationSuggestions" :key="index">
              {{ item.title }}：{{ item.content }}
            </li>
          </ul>
        </div>
      </a-card>
    </div>

    <!-- 尚未生成报告时显示的提示 -->
    <div v-if="!isGenerating && !reportGenerated" class="empty-container">
      <a-empty description="请选择题目并生成分析报告"> </a-empty>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, reactive, onMounted, onUnmounted } from "vue";
import {
  IconBulb,
  IconCode,
  IconThumbUp,
  IconInfoCircle,
  IconRobot
} from "@arco-design/web-vue/es/icon";
import message from "@arco-design/web-vue/es/message";
import AnswerCodeEditor from "@/components/AnswerCodeEditor.vue";

// 搜索参数
const searchParams = ref({
  questionId: "",
  analysisType: "all",
});

// 加载状态
const isGenerating = ref(false);
const reportGenerated = ref(false);

// 生成分析报告
const generateReport = async () => {
  if (!searchParams.value.questionId) {
    message.warning("请选择需要分析的题目");
    return;
  }

  try {
    // 设置加载状态
    isGenerating.value = true;
    reportGenerated.value = false;
    
    // 模拟API请求延迟
    await new Promise(resolve => setTimeout(resolve, 1500));
    
    // 加载报告数据（实际项目中应从API获取）
    loadMockData();
    
    // 设置报告已生成
    reportGenerated.value = true;
    message.success("分析报告生成成功");
  } catch (error) {
    message.error("生成报告失败，请稍后重试");
    console.error("生成报告失败:", error);
  } finally {
    // 无论成功还是失败，都关闭加载状态
    isGenerating.value = false;
  }
};

// 分析概览数据
const overviewData = ref([
  {
    label: "题目名称",
    value: "两数之和",
  },
  {
    label: "难度级别",
    value: "简单",
  },
  {
    label: "平均执行时间",
    value: "12ms",
  },
  {
    label: "平均内存消耗",
    value: "42.3MB",
  },
]);

// 解题思路分析
const solutionAnalysis = ref({
  understanding:
    "该问题要求在给定的整数数组中找到两个数，使它们的和等于目标值，并返回这两个数的索引。假设每个输入只有一个答案，同一个元素不能重复使用。",
  approach:
    "使用哈希表（字典）存储已遍历过的元素及其索引。对于数组中的每个元素，计算目标值与当前元素的差值，然后检查该差值是否存在于哈希表中。如果存在，则找到了答案；如果不存在，则将当前元素及其索引加入哈希表。",
  timeComplexity:
    "时间复杂度为O(n)，其中n是数组的长度。只需遍历一次数组，每次查找哈希表的时间复杂度为O(1)。",
  spaceComplexity:
    "空间复杂度为O(n)，需要一个哈希表来存储已遍历过的元素及其索引，最坏情况下可能需要存储所有元素。",
  commonErrors: [
    {
      type: "边界条件处理错误",
      description: "未考虑数组为空或只有一个元素的情况。",
    },
    {
      type: "重复使用元素",
      description: "在寻找差值时可能错误地使用了同一个元素，导致结果不正确。",
    },
    {
      type: "返回格式错误",
      description: "题目要求返回索引，但有些解答返回了元素值。",
    },
  ],
});

// 代码分析
const codeAnalysis = ref({
  java: {
    code: `class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}`,
    explanation: [
      {
        title: "数据结构选择",
        content:
          "使用HashMap存储数组元素及索引，使查找操作的时间复杂度降为O(1)。",
      },
      {
        title: "遍历逻辑",
        content:
          "在遍历过程中，首先计算当前元素与目标值的差值，然后在已遍历过的元素中查找这个差值。这样可以在一次遍历中找到答案。",
      },
      {
        title: "异常处理",
        content:
          "当找不到答案时，抛出IllegalArgumentException异常。根据题目描述，每个有效输入都应有一个解，但添加异常处理是良好的编程习惯。",
      },
    ],
  },
  cpp: {
    code: `class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash;
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];
            if (hash.count(complement)) {
                return {hash[complement], i};
            }
            hash[nums[i]] = i;
        }
        return {}; // No solution found
    }
};`,
    explanation: [
      {
        title: "数据结构选择",
        content:
          "使用C++中的unordered_map作为哈希表，查找操作的平均时间复杂度为O(1)。",
      },
      {
        title: "查找方法",
        content:
          "使用count()方法检查元素是否存在于哈希表中，这比使用find()方法更简洁。",
      },
      {
        title: "返回值处理",
        content:
          "C++中可以使用初始化列表直接构造vector，代码更加简洁。如果没有找到解决方案，返回空vector。",
      },
    ],
  },
});

// 优化建议
const optimizationSuggestions = ref([
  {
    title: "使用空间换时间",
    content:
      "通过使用哈希表存储已遍历的元素及其索引，将查找操作的时间复杂度从O(n)降低到O(1)，从而将整体算法的时间复杂度从O(n²)优化到O(n)。",
  },
  {
    title: "提前返回结果",
    content:
      "一旦找到满足条件的两个数，立即返回结果，不需要遍历整个数组。这在平均情况下可以提高效率。",
  },
  {
    title: "考虑特殊情况优化",
    content:
      "如果数组已排序，可以使用双指针法，时间复杂度为O(n)，空间复杂度为O(1)。",
  },
]);

// 根据题目ID加载对应的模拟数据
const loadMockData = () => {
  // 根据选择的题目ID加载相应数据
  switch (searchParams.value.questionId) {
    case "1869392320718675970": // 两数之和
      loadTwoSumData();
      break;
    case "1886035277244100609": // 狼抓兔子
      loadWolfCatchRabbitData();
      break;
    case "1886035673291255809": // 轮状病毒
      loadWheelVirusData();
      break;
    case "1917138790665732098": // 两数相加
      loadAddTwoNumbersData();
      break;
    case "1918578593986801666": // 多数元素
      loadMajorityElementData();
      break;
    case "1918579473574293506": // 完全平方数
      loadPerfectSquareData();
      break;
    default:
      loadTwoSumData(); // 默认加载两数之和
  }
};

// 两数之和数据
const loadTwoSumData = () => {
  overviewData.value = [
    { label: "题目名称", value: "两数之和" },
    { label: "难度级别", value: "简单" },
    { label: "平均执行时间", value: "12ms" },
    { label: "平均内存消耗", value: "42.3MB" },
  ];

  // 解题思路
  solutionAnalysis.value = {
    understanding:
      "该问题要求在给定的整数数组中找到两个数，使它们的和等于目标值，并返回这两个数的索引。假设每个输入只有一个答案，同一个元素不能重复使用。",
    approach:
      "使用哈希表（字典）存储已遍历过的元素及其索引。对于数组中的每个元素，计算目标值与当前元素的差值，然后检查该差值是否存在于哈希表中。如果存在，则找到了答案；如果不存在，则将当前元素及其索引加入哈希表。",
    timeComplexity:
      "时间复杂度为O(n)，其中n是数组的长度。只需遍历一次数组，每次查找哈希表的时间复杂度为O(1)。",
    spaceComplexity:
      "空间复杂度为O(n)，需要一个哈希表来存储已遍历过的元素及其索引，最坏情况下可能需要存储所有元素。",
    commonErrors: [
      {
        type: "边界条件处理错误",
        description: "未考虑数组为空或只有一个元素的情况。",
      },
      {
        type: "重复使用元素",
        description: "在寻找差值时可能错误地使用了同一个元素，导致结果不正确。",
      },
      {
        type: "返回格式错误",
        description: "题目要求返回索引，但有些解答返回了元素值。",
      },
    ],
  };

  // 代码分析
  codeAnalysis.value = {
    java: {
      code: `class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}`,
      explanation: [
        {
          title: "数据结构选择",
          content:
            "使用HashMap存储数组元素及索引，使查找操作的时间复杂度降为O(1)。",
        },
        {
          title: "遍历逻辑",
          content:
            "在遍历过程中，首先计算当前元素与目标值的差值，然后在已遍历过的元素中查找这个差值。这样可以在一次遍历中找到答案。",
        },
        {
          title: "异常处理",
          content:
            "当找不到答案时，抛出IllegalArgumentException异常。根据题目描述，每个有效输入都应有一个解，但添加异常处理是良好的编程习惯。",
        },
      ],
    },
    cpp: {
      code: `class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash;
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];
            if (hash.count(complement)) {
                return {hash[complement], i};
            }
            hash[nums[i]] = i;
        }
        return {}; // No solution found
    }
};`,
      explanation: [
        {
          title: "数据结构选择",
          content:
            "使用C++中的unordered_map作为哈希表，查找操作的平均时间复杂度为O(1)。",
        },
        {
          title: "查找方法",
          content:
            "使用count()方法检查元素是否存在于哈希表中，这比使用find()方法更简洁。",
        },
        {
          title: "返回值处理",
          content:
            "C++中可以使用初始化列表直接构造vector，代码更加简洁。如果没有找到解决方案，返回空vector。",
        },
      ],
    },
  };

  // 优化建议
  optimizationSuggestions.value = [
    {
      title: "使用空间换时间",
      content:
        "通过使用哈希表存储已遍历的元素及其索引，将查找操作的时间复杂度从O(n)降低到O(1)，从而将整体算法的时间复杂度从O(n²)优化到O(n)。",
    },
    {
      title: "提前返回结果",
      content:
        "一旦找到满足条件的两个数，立即返回结果，不需要遍历整个数组。这在平均情况下可以提高效率。",
    },
    {
      title: "考虑特殊情况优化",
      content:
        "如果数组已排序，可以使用双指针法，时间复杂度为O(n)，空间复杂度为O(1)。",
    },
  ];
};

// 狼抓兔子数据
const loadWolfCatchRabbitData = () => {
  overviewData.value = [
    { label: "题目名称", value: "狼抓兔子" },
    { label: "难度级别", value: "困难" },
    { label: "平均执行时间", value: "320ms" },
    { label: "平均内存消耗", value: "64.8MB" },
  ];

  // 解题思路
  solutionAnalysis.value = {
    understanding:
      "这是一个网络流问题，特别是最大流最小割问题。在一个n×m的网格中，狼从起点出发要抓住位于终点的兔子。狼每次可以向四个方向移动，而网格中的每条边都有一个容量限制。问题要求找出阻止狼到达兔子位置所需切断的边的最小总容量。",
    approach:
      "将网格构建为一个有向图，其中每个格子是一个节点，相邻格子之间有边。使用最大流算法（如Ford-Fulkerson或Dinic算法）计算从起点到终点的最大流，根据最大流最小割定理，这个最大流值就是最小割的大小。",
    timeComplexity:
      "使用Dinic算法的时间复杂度为O(V²E)，其中V是节点数量（约为n×m），E是边的数量（约为4×n×m）。在网格图中，总复杂度约为O((nm)²)。",
    spaceComplexity:
      "空间复杂度为O(V+E)，用于存储图结构和算法中的队列等数据结构，约为O(nm)。",
    commonErrors: [
      {
        type: "建图错误",
        description:
          "没有正确构建网络流模型，特别是对于网格边界的处理和边的容量设置。",
      },
      {
        type: "算法实现错误",
        description:
          "最大流算法（如Dinic、Ford-Fulkerson等）实现不正确，导致计算结果错误。",
      },
      {
        type: "边界条件处理",
        description: "没有正确处理网格边界和起点终点的特殊情况。",
      },
    ],
  };

  // 代码分析
  codeAnalysis.value = {
    java: {
      code: `import java.util.*;

public class Main {
    static final int INF = 0x3f3f3f3f;
    static final int[] dx = {0, 0, 1, -1};
    static final int[] dy = {1, -1, 0, 0};
    static int n, m, nodeNum;
    static int[][] capacity;
    static List<Integer>[] graph;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();

        // 构建网络流图
        nodeNum = n * m * 2;
        capacity = new int[nodeNum + 2][nodeNum + 2];
        graph = new ArrayList[nodeNum + 2];
        for (int i = 0; i <= nodeNum + 1; i++) {
            graph[i] = new ArrayList<>();
        }

        // 读取水平边的容量
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m - 1; j++) {
                int cap = sc.nextInt();
                int u = getNodeId(i, j, 1);
                int v = getNodeId(i, j + 1, 0);
                addEdge(u, v, cap);
            }
        }

        // 读取垂直边的容量
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < m; j++) {
                int cap = sc.nextInt();
                int u = getNodeId(i, j, 1);
                int v = getNodeId(i + 1, j, 0);
                addEdge(u, v, cap);
            }
        }

        // 设置节点内部边
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int u = getNodeId(i, j, 0);
                int v = getNodeId(i, j, 1);
                addEdge(u, v, INF);
            }
        }

        // 计算最大流
        int source = getNodeId(0, 0, 0);
        int sink = getNodeId(n - 1, m - 1, 1);
        System.out.println(maxFlow(source, sink));

        sc.close();
    }

    // 获取节点ID
    static int getNodeId(int i, int j, int k) {
        return (i * m + j) * 2 + k;
    }

    // 添加边
    static void addEdge(int u, int v, int cap) {
        graph[u].add(v);
        graph[v].add(u);
        capacity[u][v] = cap;
    }

    // Dinic算法计算最大流
    static int maxFlow(int source, int sink) {
        int[] level = new int[nodeNum + 2];
        int[] iter = new int[nodeNum + 2];
        int flow = 0;

        while (bfs(source, sink, level)) {
            Arrays.fill(iter, 0);
            int f;
            while ((f = dfs(source, sink, INF, level, iter)) > 0) {
                flow += f;
            }
        }

        return flow;
    }

    // BFS构建层次图
    static boolean bfs(int source, int sink, int[] level) {
        Arrays.fill(level, -1);
        level[source] = 0;
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(source);

        while (!queue.isEmpty()) {
            int v = queue.poll();
            for (int u : graph[v]) {
                if (level[u] < 0 && capacity[v][u] > 0) {
                    level[u] = level[v] + 1;
                    queue.offer(u);
                }
            }
        }

        return level[sink] >= 0;
    }

    // DFS寻找增广路径
    static int dfs(int v, int sink, int flow, int[] level, int[] iter) {
        if (v == sink) return flow;

        for (; iter[v] < graph[v].size(); iter[v]++) {
            int u = graph[v].get(iter[v]);
            if (level[u] == level[v] + 1 && capacity[v][u] > 0) {
                int d = dfs(u, sink, Math.min(flow, capacity[v][u]), level, iter);
                if (d > 0) {
                    capacity[v][u] -= d;
                    capacity[u][v] += d;
                    return d;
                }
            }
        }
        
        return 0;
    }
}`,
      explanation: [
        {
          title: "网络流建模",
          content:
            "将网格问题转化为网络流问题，每个格子被分为入节点和出节点，使用剩余网络模型处理。",
        },
        {
          title: "Dinic算法实现",
          content:
            "使用Dinic算法计算最大流，包括BFS构建分层图和DFS寻找增广路径两个主要步骤。",
        },
        {
          title: "节点编号技巧",
          content:
            "使用二维坐标到一维索引的映射技巧，并为每个格子创建两个节点（入节点和出节点），以处理格子内部的流量限制。",
        },
      ],
    },
    cpp: {
      code: `#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;

const int MAXN = 50;
const int INF = 0x3f3f3f3f;
const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};

int n, m, nodeNum;
int cap[MAXN*MAXN*2][MAXN*MAXN*2];
vector<int> G[MAXN*MAXN*2];
int level[MAXN*MAXN*2], iter[MAXN*MAXN*2];

// 获取节点ID
inline int getNodeId(int i, int j, int k) {
    return (i * m + j) * 2 + k;
}

// 添加边
void addEdge(int from, int to, int capacity) {
    G[from].push_back(to);
    G[to].push_back(from);
    cap[from][to] = capacity;
}

// BFS构建层次图
bool bfs(int s, int t) {
    memset(level, -1, sizeof(level));
    level[s] = 0;
    queue<int> q;
    q.push(s);
    
    while (!q.empty()) {
        int v = q.front(); q.pop();
        for (int i = 0; i < G[v].size(); i++) {
            int u = G[v][i];
            if (level[u] < 0 && cap[v][u] > 0) {
                level[u] = level[v] + 1;
                q.push(u);
            }
        }
    }
    
    return level[t] >= 0;
}

// DFS寻找增广路径
int dfs(int v, int t, int f) {
    if (v == t) return f;
    for (int &i = iter[v]; i < G[v].size(); i++) {
        int u = G[v][i];
        if (level[u] == level[v] + 1 && cap[v][u] > 0) {
            int d = dfs(u, t, min(f, cap[v][u]));
            if (d > 0) {
                cap[v][u] -= d;
                cap[u][v] += d;
                return d;
            }
        }
    }
    return 0;
}

// Dinic算法计算最大流
int maxFlow(int s, int t) {
    int flow = 0;
    while (bfs(s, t)) {
        memset(iter, 0, sizeof(iter));
        int f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
    return flow;
}

int main() {
    cin >> n >> m;
    
    // 构建网络流图
    nodeNum = n * m * 2;
    
    // 读取水平边的容量
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m - 1; j++) {
            int c;
            cin >> c;
            int u = getNodeId(i, j, 1);
            int v = getNodeId(i, j + 1, 0);
            addEdge(u, v, c);
        }
    }
    
    // 读取垂直边的容量
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < m; j++) {
            int c;
            cin >> c;
            int u = getNodeId(i, j, 1);
            int v = getNodeId(i + 1, j, 0);
            addEdge(u, v, c);
        }
    }
    
    // 设置格子内部边
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int u = getNodeId(i, j, 0);
            int v = getNodeId(i, j, 1);
            addEdge(u, v, INF);
        }
    }
    
    // 计算最大流
    int source = getNodeId(0, 0, 0);
    int sink = getNodeId(n - 1, m - 1, 1);
    cout << maxFlow(source, sink) << endl;
    
    return 0;
}`,
      explanation: [
        {
          title: "数据结构选择",
          content:
            "使用静态数组存储容量矩阵和邻接表，避免动态分配内存的开销，提高执行效率。",
        },
        {
          title: "Dinic算法",
          content:
            "通过分层图的构建和多次增广路径搜索来实现最大流算法，效率高于基础的Ford-Fulkerson算法。",
        },
        {
          title: "内存优化",
          content:
            "使用预定义的最大大小来避免动态内存分配，提高程序运行效率，适合竞赛环境。",
        },
      ],
    },
  };

  // 优化建议
  optimizationSuggestions.value = [
    {
      title: "图的构建优化",
      content: "预先计算图的大小，减少不必要的内存分配，可以降低初始化时间。",
    },
    {
      title: "算法优化",
      content:
        "使用ISAP或HLPP等算法可能比Dinic算法有更好的性能，特别是在稠密图上。",
    },
    {
      title: "内存使用优化",
      content:
        "可以使用邻接表而非邻接矩阵来存储图，当图比较稀疏时可以节省大量内存。",
    },
  ];
};

// 轮状病毒数据
const loadWheelVirusData = () => {
  overviewData.value = [
    { label: "题目名称", value: "轮状病毒" },
    { label: "难度级别", value: "中等" },
    { label: "平均执行时间", value: "85ms" },
    { label: "平均内存消耗", value: "38.6MB" },
  ];

  // 解题思路
  solutionAnalysis.value = {
    understanding:
      "轮状病毒是一个特殊的树形结构问题。每个轮状病毒由一个中心点和若干个分支组成，每个分支又是一个更小的轮状病毒。问题要求计算指定大小的轮状病毒数量。",
    approach:
      "这个问题可以通过卡特兰数（Catalan Number）来解决。轮状病毒的计数问题本质上是计算不同形状的树的数量，这正好符合卡特兰数的递推公式：C(n+1) = Σ(C(i)*C(n-i))，其中i从0到n。由于结果可能很大，需要使用大整数库处理。",
    timeComplexity:
      "使用动态规划计算卡特兰数的时间复杂度为O(n²)，其中n是要求的轮状病毒大小。",
    spaceComplexity:
      "空间复杂度为O(n)，主要用于存储动态规划的中间结果，以及大整数的存储空间。",
    commonErrors: [
      {
        type: "递推公式错误",
        description: "错误地理解或应用卡特兰数的递推公式，导致计算结果不正确。",
      },
      {
        type: "大数处理不当",
        description:
          "没有使用适当的大整数库或算法处理可能出现的大数，导致整数溢出。",
      },
      {
        type: "边界条件处理",
        description: "对n=0或n=1等特殊情况的处理不正确。",
      },
    ],
  };

  // 代码分析
  codeAnalysis.value = {
    java: {
      code: `import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        scanner.close();
        
        // 使用BigInteger处理大数
        BigInteger[] dp = new BigInteger[n + 1];
        dp[0] = BigInteger.ONE;
        
        // 计算卡特兰数
        for (int i = 1; i <= n; i++) {
            dp[i] = BigInteger.ZERO;
            for (int j = 0; j < i; j++) {
                // dp[i] += dp[j] * dp[i-j-1]
                dp[i] = dp[i].add(dp[j].multiply(dp[i - j - 1]));
            }
        }
        
        System.out.println(dp[n]);
    }
}`,
      explanation: [
        {
          title: "卡特兰数应用",
          content:
            "使用卡特兰数的递推公式来解决轮状病毒计数问题，dp[n]表示大小为n的轮状病毒数量。",
        },
        {
          title: "大整数处理",
          content: "使用Java的BigInteger类处理大数计算，避免整数溢出问题。",
        },
        {
          title: "动态规划实现",
          content:
            "通过自底向上的方式计算卡特兰数，避免递归带来的重复计算问题。",
        },
      ],
    },
    cpp: {
      code: `#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 自定义大整数类
class BigInteger {
private:
    static const int BASE = 10000; // 基数
    static const int WIDTH = 4;    // 每个数位的宽度
    vector<int> digits;           // 存储每个数位的值

public:
    BigInteger(long long num = 0) { *this = num; }
    
    BigInteger& operator = (long long num) {
        digits.clear();
        do {
            digits.push_back(num % BASE);
            num /= BASE;
        } while(num > 0);
        return *this;
    }
    
    BigInteger operator + (const BigInteger& b) const {
        BigInteger result;
        result.digits.clear();
        
        int carry = 0;
        for(int i = 0; i < max(digits.size(), b.digits.size()) || carry; i++) {
            int sum = carry;
            if(i < digits.size()) sum += digits[i];
            if(i < b.digits.size()) sum += b.digits[i];
            
            result.digits.push_back(sum % BASE);
            carry = sum / BASE;
        }
        
        return result;
    }
    
    BigInteger operator * (const BigInteger& b) const {
        BigInteger result;
        result.digits.resize(digits.size() + b.digits.size(), 0);
        
        for(int i = 0; i < digits.size(); i++) {
            int carry = 0;
            for(int j = 0; j < b.digits.size() || carry; j++) {
                long long current = result.digits[i + j] + 
                                   (long long)digits[i] * (j < b.digits.size() ? b.digits[j] : 0) + 
                                   carry;
                result.digits[i + j] = current % BASE;
                carry = current / BASE;
            }
        }
        
        while(result.digits.size() > 1 && result.digits.back() == 0)
            result.digits.pop_back();
            
        return result;
    }
    
    friend ostream& operator << (ostream &out, const BigInteger& num) {
        out << (num.digits.empty() ? 0 : num.digits.back());
        for(int i = num.digits.size() - 2; i >= 0; i--) {
            out.width(WIDTH);
            out.fill('0');
            out << num.digits[i];
        }
        return out;
    }
};

int main() {
    int n;
    cin >> n;
    
    // 使用动态规划计算卡特兰数
    vector<BigInteger> dp(n + 1);
    dp[0] = 1;
    
    for(int i = 1; i <= n; i++) {
        dp[i] = 0;
        for(int j = 0; j < i; j++) {
            dp[i] = dp[i] + dp[j] * dp[i - j - 1];
        }
    }
    
    cout << dp[n] << endl;
    return 0;
}`,
      explanation: [
        {
          title: "大整数实现",
          content:
            "实现了自定义的BigInteger类，用于处理大整数计算，支持加法和乘法运算。",
        },
        {
          title: "算法效率",
          content:
            "使用向量存储数字的每个位，采用高效的基于位的乘法算法，并通过合理设置基数(10000)减少乘法运算次数。",
        },
        {
          title: "数学优化",
          content:
            "应用卡特兰数的递推关系，避免使用组合数公式直接计算，减少计算量和溢出风险。",
        },
      ],
    },
  };

  // 优化建议
  optimizationSuggestions.value = [
    {
      title: "数学公式优化",
      content:
        "可以使用卡特兰数的封闭形式：C(n) = (2n)! / (n! * (n+1)!)，但需要处理阶乘计算中的大数问题。",
    },
    {
      title: "记忆化搜索",
      content:
        "对于较小的n，可以使用记忆化搜索代替动态规划，可能在某些情况下有更好的性能。",
    },
    {
      title: "并行计算",
      content:
        "卡特兰数的计算可以在计算dp[i]时并行处理各个j的乘积，在多核环境下可能提高效率。",
    },
  ];
};

// 多数元素数据
const loadMajorityElementData = () => {
  overviewData.value = [
    { label: "题目名称", value: "多数元素" },
    { label: "难度级别", value: "简单" },
    { label: "平均执行时间", value: "12ms" },
    { label: "平均内存消耗", value: "42.3MB" },
  ];

  // 解题思路
  solutionAnalysis.value = {
    understanding:
      "该问题要求在给定的整数数组中找到出现次数最多的元素。假设每个输入只有一个答案，同一个元素不能重复使用。",
    approach:
      "使用哈希表（字典）存储已遍历过的元素及其出现次数。对于数组中的每个元素，检查该元素是否存在于哈希表中。如果存在，则增加其出现次数；如果不存在，则将当前元素及其出现次数加入哈希表。",
    timeComplexity:
      "时间复杂度为O(n)，其中n是数组的长度。只需遍历一次数组，每次查找哈希表的时间复杂度为O(1)。",
    spaceComplexity:
      "空间复杂度为O(n)，需要一个哈希表来存储已遍历过的元素及其出现次数，最坏情况下可能需要存储所有元素。",
    commonErrors: [
      {
        type: "边界条件处理错误",
        description: "未考虑数组为空或只有一个元素的情况。",
      },
      {
        type: "重复使用元素",
        description: "在寻找多数元素时可能错误地使用了同一个元素，导致结果不正确。",
      },
      {
        type: "返回格式错误",
        description: "题目要求返回元素，但有些解答返回了元素值。",
      },
    ],
  };

  // 代码分析
  codeAnalysis.value = {
    java: {
      code: `class Solution {
    public int majorityElement(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int count = map.getOrDefault(nums[i], 0) + 1;
            map.put(nums[i], count);
            if (count > nums.length / 2) {
                return nums[i];
            }
        }
        throw new IllegalArgumentException("No majority element");
    }
}`,
      explanation: [
        {
          title: "数据结构选择",
          content:
            "使用HashMap存储数组元素及出现次数，使查找操作的时间复杂度降为O(1)。",
        },
        {
          title: "遍历逻辑",
          content:
            "在遍历过程中，首先计算当前元素的出现次数，然后在已遍历过的元素中查找这个元素。这样可以在一次遍历中找到答案。",
        },
        {
          title: "异常处理",
          content:
            "当找不到答案时，抛出IllegalArgumentException异常。根据题目描述，每个有效输入都应有一个解，但添加异常处理是良好的编程习惯。",
        },
      ],
    },
    cpp: {
      code: `class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int, int> hash;
        for (int i = 0; i < nums.size(); i++) {
            int count = hash[nums[i]] + 1;
            hash[nums[i]] = count;
            if (count > nums.size() / 2) {
                return nums[i];
            }
        }
        return -1; // No majority element found
    }
};`,
      explanation: [
        {
          title: "数据结构选择",
          content:
            "使用C++中的unordered_map作为哈希表，查找操作的平均时间复杂度为O(1)。",
        },
        {
          title: "查找方法",
          content:
            "使用count()方法检查元素是否存在于哈希表中，这比使用find()方法更简洁。",
        },
        {
          title: "返回值处理",
          content:
            "C++中可以使用初始化列表直接构造vector，代码更加简洁。如果没有找到解决方案，返回-1。",
        },
      ],
    },
  };

  // 优化建议
  optimizationSuggestions.value = [
    {
      title: "使用空间换时间",
      content:
        "通过使用哈希表存储已遍历的元素及其出现次数，将查找操作的时间复杂度从O(n)降低到O(1)，从而将整体算法的时间复杂度从O(n²)优化到O(n)。",
    },
    {
      title: "提前返回结果",
      content:
        "一旦找到满足条件的多数元素，立即返回结果，不需要遍历整个数组。这在平均情况下可以提高效率。",
    },
    {
      title: "考虑特殊情况优化",
      content:
        "如果数组已排序，可以使用双指针法，时间复杂度为O(n)，空间复杂度为O(1)。",
    },
  ];
};

// 完全平方数数据
const loadPerfectSquareData = () => {
  overviewData.value = [
    { label: "题目名称", value: "完全平方数" },
    { label: "难度级别", value: "简单" },
    { label: "平均执行时间", value: "12ms" },
    { label: "平均内存消耗", value: "42.3MB" },
  ];

  // 解题思路
  solutionAnalysis.value = {
    understanding:
      "该问题要求判断一个整数是否是完全平方数。假设每个输入只有一个答案，同一个元素不能重复使用。",
    approach:
      "使用二分查找法查找完全平方数。对于一个整数n，计算其平方根的整数部分，然后检查这个整数部分的平方是否等于n。",
    timeComplexity:
      "时间复杂度为O(logn)，其中n是输入整数。只需进行一次二分查找，每次查找的时间复杂度为O(1)。",
    spaceComplexity:
      "空间复杂度为O(1)，不需要额外的存储空间。",
    commonErrors: [
      {
        type: "边界条件处理错误",
        description: "未考虑输入整数为0或负数的情况。",
      },
      {
        type: "二分查找错误",
        description: "二分查找法实现不正确，导致计算结果错误。",
      },
      {
        type: "返回格式错误",
        description: "题目要求返回布尔值，但有些解答返回了整数值。",
      },
    ],
  };

  // 代码分析
  codeAnalysis.value = {
    java: {
      code: `class Solution {
    public boolean isPerfectSquare(int num) {
        if (num < 2) {
            return true;
        }
        int left = 2;
        int right = num / 2;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            long square = (long) mid * mid;
            if (square == num) {
                return true;
            } else if (square < num) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return false;
    }
}`,
      explanation: [
        {
          title: "二分查找法",
          content:
            "使用二分查找法查找完全平方数，时间复杂度为O(logn)。",
        },
        {
          title: "边界条件处理",
          content:
            "正确处理输入整数为0或负数的情况，返回true。",
        },
        {
          title: "返回值处理",
          content:
            "返回布尔值，表示输入整数是否是完全平方数。",
        },
      ],
    },
    cpp: {
      code: `class Solution {
public:
    bool isPerfectSquare(int num) {
        if (num < 2) {
            return true;
        }
        int left = 2;
        int right = num / 2;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            long long square = (long long) mid * mid;
            if (square == num) {
                return true;
            } else if (square < num) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return false;
    }
};`,
      explanation: [
        {
          title: "二分查找法",
          content:
            "使用二分查找法查找完全平方数，时间复杂度为O(logn)。",
        },
        {
          title: "边界条件处理",
          content:
            "正确处理输入整数为0或负数的情况，返回true。",
        },
        {
          title: "返回值处理",
          content:
            "返回布尔值，表示输入整数是否是完全平方数。",
        },
      ],
    },
  };

  // 优化建议
  optimizationSuggestions.value = [
    {
      title: "使用数学公式",
      content:
        "可以使用完全平方数的数学公式：n = k^2，其中k是整数。这种方法可以避免二分查找法的复杂度。",
    },
    {
      title: "提前返回结果",
      content:
        "一旦找到满足条件的完全平方数，立即返回结果，不需要继续查找。这在平均情况下可以提高效率。",
    },
    {
      title: "考虑特殊情况优化",
      content:
        "如果输入整数是完全平方数，可以直接返回true，而不需要进行二分查找。",
    },
  ];
};

// 两数相加数据
const loadAddTwoNumbersData = () => {
  overviewData.value = [
    { label: "题目名称", value: "两数相加" },
    { label: "难度级别", value: "中等" },
    { label: "平均执行时间", value: "2ms" },
    { label: "平均内存消耗", value: "39.4MB" },
  ];

  // 解题思路
  solutionAnalysis.value = {
    understanding:
      "该问题要求将两个非空链表表示的非负整数相加，并以链表形式返回结果。链表中的每个节点存储一个数字（0-9），且数字按照逆序方式存储（即个位在链表头部）。",
    approach:
      "从两个链表的头部开始同时遍历，将对应位置的数字相加（需考虑进位），并创建新的节点存储结果。当两个链表长度不同时，较短的链表可视为在高位补0。",
    timeComplexity:
      "时间复杂度为O(max(m,n))，其中m和n分别是两个链表的长度。需要遍历两个链表中较长的那个。",
    spaceComplexity:
      "空间复杂度为O(max(m,n))，需要创建一个新链表来存储结果，其长度最多为max(m,n)+1（考虑最高位的进位）。",
    commonErrors: [
      {
        type: "进位处理错误",
        description: "忘记处理或错误处理进位，导致结果不正确。",
      },
      {
        type: "链表长度不同处理错误",
        description: "当两个链表长度不同时，没有正确处理较短链表的结束情况。",
      },
      {
        type: "边界条件处理",
        description: "没有考虑最后可能存在的进位，导致结果少一位。",
      },
    ],
  };

  // 代码分析
  codeAnalysis.value = {
    java: {
      code: `/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(0);
        ListNode current = dummyHead;
        int carry = 0;
        
        while (l1 != null || l2 != null) {
            int x = (l1 != null) ? l1.val : 0;
            int y = (l2 != null) ? l2.val : 0;
            int sum = x + y + carry;
            
            carry = sum / 10;
            current.next = new ListNode(sum % 10);
            current = current.next;
            
            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }
        
        if (carry > 0) {
            current.next = new ListNode(carry);
        }
        
        return dummyHead.next;
    }
}`,
      explanation: [
        {
          title: "链表遍历",
          content:
            "同时遍历两个链表，处理每个位置的数字相加，并考虑进位。",
        },
        {
          title: "哑节点技巧",
          content:
            "使用哑节点（dummy head）简化代码，避免对头节点的特殊处理。",
        },
        {
          title: "进位处理",
          content:
            "使用变量carry存储进位，并在每次计算中考虑上一位的进位。最后检查是否还有进位需要添加到结果链表中。",
        },
      ],
    },
    cpp: {
      code: `/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummyHead = new ListNode(0);
        ListNode* current = dummyHead;
        int carry = 0;
        
        while (l1 != nullptr || l2 != nullptr) {
            int x = (l1 != nullptr) ? l1->val : 0;
            int y = (l2 != nullptr) ? l2->val : 0;
            int sum = x + y + carry;
            
            carry = sum / 10;
            current->next = new ListNode(sum % 10);
            current = current->next;
            
            if (l1 != nullptr) l1 = l1->next;
            if (l2 != nullptr) l2 = l2->next;
        }
        
        if (carry > 0) {
            current->next = new ListNode(carry);
        }
        
        ListNode* result = dummyHead->next;
        delete dummyHead;
        return result;
    }
};`,
      explanation: [
        {
          title: "内存管理",
          content:
            "在C++中需要手动管理内存，创建新节点使用new操作符，并在最后删除哑节点避免内存泄漏。",
        },
        {
          title: "指针操作",
          content:
            "使用指针操作链表节点，通过->访问节点的值和下一个节点。",
        },
        {
          title: "空指针检查",
          content:
            "使用nullptr检查链表是否结束，确保安全访问节点值。",
        },
      ],
    },
  };

  // 优化建议
  optimizationSuggestions.value = [
    {
      title: "提前终止",
      content:
        "当两个链表都遍历完且没有进位时，可以提前终止循环，避免不必要的迭代。",
    },
    {
      title: "原地修改",
      content:
        "如果允许修改输入链表，可以考虑在较长的链表上直接修改，减少空间使用。",
    },
    {
      title: "大数处理",
      content:
        "对于非常长的链表（表示非常大的数），可以考虑分块处理，减少内存占用。",
    },
  ];
};

// 生命周期钩子
onMounted(() => {
  // 移除resize事件监听
});

onUnmounted(() => {
  // 移除resize事件监听
});

// 处理代码编辑器内容变化的函数
const handleCodeChange = (value: string) => {
  // 这里是只读展示，不做任何处理
  console.log("代码已更新，但在此处不做处理");
};
</script>

<style scoped>
#aiReportView {
  max-width: 1000px;
  margin: 0 auto;
  padding: 24px;
  min-height: calc(100vh - 160px);
}

.header-section {
  margin-bottom: 32px;
  text-align: center;
}

.page-title {
  font-size: 28px;
  font-weight: 600;
  color: #1d2129;
  margin-bottom: 24px;
}

.selection-container {
  background-color: #fff;
  border-radius: 12px;
  padding: 24px;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
  display: flex;
  justify-content: center;
}

:deep(.question-select .arco-select-view) {
  border-radius: 8px;
  padding: 8px 12px;
  border-color: #e5e6eb;
}

.generate-btn {
  border-radius: 8px;
  padding: 0 24px;
  height: 40px;
  font-weight: 500;
  background-color: #4080ff;
}

.empty-container {
  display: flex;
  justify-content: center;
  align-items: center;
  min-height: 400px;
}

.empty-content {
  text-align: center;
  padding: 40px;
}

.empty-icon {
  font-size: 64px;
  color: #4080ff;
  margin-bottom: 24px;
}

.empty-title {
  font-size: 24px;
  font-weight: 600;
  color: #1d2129;
  margin-bottom: 12px;
}

.empty-desc {
  font-size: 16px;
  color: #86909c;
  max-width: 500px;
  margin: 0 auto;
}

.loading-container {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  padding: 80px 0;
  min-height: 400px;
}

.loading-text {
  margin-top: 36px;
  text-align: center;
}

.loading-text h2 {
  font-size: 24px;
  font-weight: 600;
  color: #1d2129;
  margin-bottom: 12px;
}

.loading-tips {
  color: #86909c;
  font-size: 16px;
}

.report-container {
  display: flex;
  flex-direction: column;
  gap: 24px;
}

.report-section {
  background-color: #fff;
  border-radius: 12px;
  overflow: hidden;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
  padding: 24px;
  margin-bottom: 0;
}

.section-header {
  display: flex;
  align-items: center;
  margin-bottom: 16px;
}

.section-icon {
  font-size: 20px;
  color: #4080ff;
  margin-right: 8px;
}

.section-title {
  font-size: 18px;
  font-weight: 600;
  color: #1d2129;
}

.solution-analysis {
  display: flex;
  flex-direction: column;
  gap: 20px;
  padding: 8px;
}

.analysis-item h3 {
  display: flex;
  align-items: center;
  gap: 8px;
  margin-bottom: 12px;
  font-size: 16px;
  font-weight: 600;
  color: #1d2129;
}

.analysis-item p {
  color: #4e5969;
  line-height: 1.6;
  font-size: 15px;
}

:deep(.arco-descriptions-bordered) {
  border-radius: 8px;
  overflow: hidden;
}

:deep(.arco-descriptions-item-label) {
  font-weight: 500;
}

.chart-container {
  display: flex;
  justify-content: center;
  align-items: center;
  margin-top: 32px;
  width: 100%;
}

.chart {
  width: 100%;
  max-width: 500px;
  margin: 0 auto;
}

.chart-box {
  height: 300px;
  width: 100%;
  margin: 0 auto;
  border-radius: 8px;
  overflow: hidden;
}

.code-analysis {
  display: flex;
  flex-direction: column;
  gap: 24px;
}

.code-container {
  background-color: transparent;
  border-radius: 8px;
  padding: 12px;
  overflow-x: auto;
  height: 150px;
  width: 100%;
}

.explanation-container {
  flex: 1;
  padding-top: 16px;
}

.explanation-container h3 {
  margin-bottom: 16px;
  font-size: 16px;
  font-weight: 600;
  color: #1d2129;
}

.suggestion-item h3 {
  margin-bottom: 8px;
  font-size: 16px;
  font-weight: 600;
  color: #1d2129;
}

.suggestion-code {
  margin-top: 8px;
  background-color: #f7f8fa;
  border-radius: 4px;
  padding: 8px;
}
</style>
